home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / mint / shells / bashsrc.zoo / dispose_cmd.c < prev    next >
C/C++ Source or Header  |  1991-06-05  |  4KB  |  176 lines
  1. /* dispose_command.c -- dispose of a COMMAND structure. */
  2.  
  3. /* Copyright (C) 1989 Free Software Foundation, Inc.
  4.  
  5.    This file is part of GNU Bash, the Bourne Again SHell.
  6.  
  7.    Bash is free software; you can redistribute it and/or modify it under
  8.    the terms of the GNU General Public License as published by the Free
  9.    Software Foundation; either version 1, or (at your option) any later
  10.    version.
  11.  
  12.    Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  13.    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14.    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15.    for more details.
  16.  
  17.    You should have received a copy of the GNU General Public License along
  18.    with Bash; see the file COPYING.  If not, write to the Free Software
  19.    Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20.  
  21. #include "shell.h"
  22.  
  23. /* Dispose of the command structure passed. */
  24. dispose_command (command)
  25.      register COMMAND *command;
  26. {
  27.   if (!command) return;
  28.  
  29.   if (command->redirects)
  30.     dispose_redirects (command->redirects);
  31.  
  32.   switch (command->type)
  33.     {
  34.     case cm_for:
  35.       {
  36.     register FOR_COM *c = command->value.For;
  37.     dispose_word (c->name);
  38.     dispose_words (c->map_list);
  39.     dispose_command (c->action);
  40.     free (c);
  41.     break;
  42.       }
  43.     
  44.     case cm_group:
  45.       {
  46.     dispose_command (command->value.Group->command);
  47.     break;
  48.       }
  49.  
  50.     case cm_case:
  51.       {
  52.     register CASE_COM *c = command->value.Case;
  53.     PATTERN_LIST *t, *p = c->clauses;
  54.     dispose_word (c->word);
  55.     while (p) {
  56.       dispose_words (p->patterns);
  57.       dispose_command (p->action);
  58.       t = p;
  59.       p = p->next;
  60.       free (t);
  61.     }
  62.     break;
  63.       }
  64.  
  65.     case cm_until:
  66.     case cm_while:
  67.       {
  68.     register WHILE_COM *c = command->value.While;
  69.     dispose_command (c->test);
  70.     dispose_command (c->action);
  71.     free (c);
  72.     break;
  73.       }
  74.  
  75.     case cm_if:
  76.       {
  77.     register IF_COM *c = command->value.If;
  78.     dispose_command (c->test);
  79.     dispose_command (c->true_case);
  80.     dispose_command (c->false_case);
  81.     free (c);
  82.     break;
  83.       }
  84.  
  85.     case cm_simple:
  86.       {
  87.     register SIMPLE_COM *c = command->value.Simple;
  88.     dispose_words (c->words);
  89.     dispose_redirects (c->redirects);
  90.     free (c);
  91.     break;
  92.       }
  93.  
  94.     case cm_connection:
  95.       {
  96.     register CONNECTION *c = command->value.Connection;
  97.     dispose_command (c->first);
  98.     dispose_command (c->second);
  99.     free (c);
  100.     break;
  101.       }
  102.  
  103.     case cm_function_def:
  104.       {
  105.     register FUNCTION_DEF *c = command->value.Function_def;
  106.     dispose_word (c->name);
  107.     dispose_command (c->command);
  108.     free (c);
  109.     break;
  110.       }
  111.  
  112.     default:
  113.       report_error ("Attempt to free unknown command type `%d'.\n", command->type);
  114.       break;
  115.     }
  116.   free (command);
  117. }
  118.  
  119. /* How to free a WORD_DESC. */
  120. dispose_word (word)
  121.      WORD_DESC *word;
  122. {
  123.   free (word->word);
  124.   free (word);
  125. }
  126.  
  127. /* How to get rid of a linked list of words.  A WORD_LIST. */
  128. dispose_words (list)
  129.      WORD_LIST *list;
  130. {
  131.   WORD_LIST *t;
  132.   while (list) {
  133.     t = list;
  134.     list = list->next;
  135.     dispose_word (t->word);
  136.     free (t);
  137.   }
  138. }
  139.  
  140. /* How to dispose of an array of pointers to char. */
  141. dispose_word_array (array)
  142.      char **array;
  143. {
  144.   int count = 0;
  145.   for (count = 0; array[count]; count++)
  146.     free (array[count]);
  147.   free (array);
  148. }
  149.  
  150. /* How to dispose of an list of redirections.  A REDIRECT. */
  151. dispose_redirects (list)
  152.      REDIRECT *list;
  153. {
  154.   register REDIRECT *t;
  155.  
  156.   while (list) {
  157.     t = list;
  158.     list = list->next;
  159.     switch (t->instruction) {
  160.  
  161.     case r_reading_until:
  162.     case r_deblank_reading_until:
  163.       free (t->here_doc_eof);
  164.       /* ... */
  165.     case r_output_direction:
  166.     case r_input_direction:
  167.     case r_inputa_direction:
  168.     case r_appending_to:
  169.     case r_err_and_out:
  170.       dispose_word (t->redirectee.filename);
  171.       break;
  172.     }
  173.     free (t);
  174.   }
  175. }
  176.